/**
 * @file mainwindow.cpp
 * @brief 串口调试工具 - 主窗口核心实现文件
 * 
 * 本文件是串口调试工具的核心实现，包含MainWindow类的基础功能：
 * - 类构造函数和析构函数
 * - 主窗口UI初始化
 * - 核心对象创建和配置
 * - 全局信号槽连接
 * - 快捷键定义和处理
 * - 错误处理机制初始化
 * 
 * 功能模块化说明：
 * - serial_manager.h/cpp: 负责串口扫描、参数配置和连接管理
 * - data_io.h/cpp: 负责数据收发和格式化功能
 * - utils.h/cpp: 提供通用工具函数
 * - settings_manager.h/cpp: 负责应用设置的保存和加载
 */

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "serial_manager.h"
#include "data_io.h"
#include "settings_manager.h"
#include <QStatusBar>
#include <QMessageBox>
#include <QDebug>
#include <QShortcut>
#include <QDateTime>
#include <QAction>
#include <QActionGroup>
#include <QToolBar>
#include <QTabBar>
#include <QCloseEvent>
#include <QFileDialog>
#include <QFile>
#include <QCheckBox>
#include <QTimer>
#include <QTextCursor>
#include <QTextCharFormat>
#include <QBrush>
#include <QSpinBox>
#include <QTextDocument>
#include <QTextBlock>
#include <QPushButton>
#include <QRadioButton>
#include <QButtonGroup>
#include <QSlider>
#include <QScrollBar>
#include <QDialog>
#include <QFormLayout>
#include <QComboBox>
#include <QDialogButtonBox>

/**
 * @brief MainWindow类构造函数
 * @param parent 父窗口指针
 * 
 * 构造函数负责初始化MainWindow类的所有核心组件和状态，包括：
 * 1. 创建和初始化UI组件
 * 2. 实例化核心对象（串口、定时器）
 * 3. 初始化状态标志
 * 4. 配置串口参数
 * 5. 连接关键信号槽
 * 6. 设置键盘快捷键
 * 7. 配置错误处理机制
 * 
 * 关键初始化步骤：
 * - 创建新的UI对象和串口对象
 * - 创建并配置自动发送定时器
 * - 初始化所有状态标志为默认值
 * - 设置窗口标题
 * - 调用setupSerialPort()配置串口默认参数
 * - 填充波特率和可用串口列表
 * - 配置波特率下拉框为可编辑状态
 * - 设置窗口操作快捷键
 * - 连接串口事件处理函数
 * - 设置错误处理回调
 */
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    serialManager(new SerialManager(this)),
    dataIO(new DataIO(serialManager->getSerialPort(), this)),
    settingsManager(new SettingsManager("UartTool", "UartToolApp", this)),
    ui(new Ui::MainWindow),
    autoSendTimer(new QTimer(this)),
    isConnected(false),
    isHexSend(false),
    isHexReceive(false),
    isAutoSend(false),
    isTimestampEnabled(false),
    isAutoScrollEnabled(true),
    errorMessageBoxActive(false),
    pauseReceiving(false),
    maxRetainedLines(1000)
{
    ui->setupUi(this);
    setWindowTitle("串口调试工具");
    
    // 初始化UI和信号槽
    initializeUI();
    connectSignalsSlots();
    
    // 填充波特率列表
    ui->baudRateComboBox->clear();
    ui->baudRateComboBox->addItems(serialManager->populateBaudRateList());
    ui->baudRateComboBox->setEditable(true);

    // 快捷键：窗口
    QShortcut *minimizeShortcut = new QShortcut(QKeySequence("Esc"), this);
    connect(minimizeShortcut, &QShortcut::activated, this, &MainWindow::showMinimized);
    QShortcut *closeShortcut = new QShortcut(QKeySequence("Ctrl+W"), this);
    connect(closeShortcut, &QShortcut::activated, this, &MainWindow::close);

    // 快捷键：核心操作（禁用 Ctrl+E / Ctrl+L / Ctrl+K）
    QShortcut *toggleAutoSend = new QShortcut(QKeySequence("Ctrl+Shift+A"), this);
    connect(toggleAutoSend, &QShortcut::activated, this, [this](){
        if (QCheckBox* cb = this->findChild<QCheckBox*>("autoSendCheckBox")) {
            cb->click();
        } else {
            // 回退：直接切换状态
            isAutoSend = !isAutoSend;
            if (isAutoSend) {
                autoSendTimer->start();
            } else {
                autoSendTimer->stop();
            }
        }
    });
    QShortcut *exportRecv = new QShortcut(QKeySequence("Ctrl+Shift+E"), this);
    connect(exportRecv, &QShortcut::activated, this, &MainWindow::exportReceiveToFile);

    // 信号槽
    connect(autoSendTimer, &QTimer::timeout, this, &MainWindow::sendData);
    ui->receiveTextEdit->viewport()->installEventFilter(this);
    // 发送输入变更时做校验
    connect(ui->sendTextEdit, &QTextEdit::textChanged, this, &MainWindow::validateSendInput);

    // 可选控件：暂停接收、最大保留行数
    if (QCheckBox* pauseCb = this->findChild<QCheckBox*>("pauseReceiveCheckBox")) {
        pauseReceiving = pauseCb->isChecked();
        connect(pauseCb, &QCheckBox::checkStateChanged, this, [this](Qt::CheckState state){
        pauseReceiving = (state == Qt::Checked);
        showStatusMessage(pauseReceiving ? "接收已暂停" : "接收已恢复");
        });
    }
    if (QSpinBox* maxLinesSpin = this->findChild<QSpinBox*>("maxLinesSpinBox")) {
        maxRetainedLines = maxLinesSpin->value();
        connect(maxLinesSpin, QOverload<int>::of(&QSpinBox::valueChanged), this, [this](int v){
            maxRetainedLines = v;
            enforceMaxLines();
            showStatusMessage(QString("最大保留行数: %1").arg(v));
        });
    }

    // 加载设置并更新状态栏
    loadSettings();
    updateStatsStatusBar();
    
    // 初始化并设置时间戳显示按钮为可检查状态
    if (QPushButton* timestampBtn = ui->timestampButton) {
        timestampBtn->setCheckable(true);
        timestampBtn->setChecked(isTimestampEnabled);
        connect(timestampBtn, &QPushButton::toggled, this, [this](bool checked){
            isTimestampEnabled = checked;
            if (isTimestampEnabled) {
                showStatusMessage("时间戳显示已启用");
            } else {
                showStatusMessage("时间戳显示已禁用");
            }
        });
    }
    
    // 初始化并设置自动滚动按钮为可检查状态
    if (QPushButton* autoScrollBtn = ui->autoScrollButton) {
        autoScrollBtn->setCheckable(true);
        autoScrollBtn->setChecked(isAutoScrollEnabled);
        connect(autoScrollBtn, &QPushButton::toggled, this, [this](bool checked){
            isAutoScrollEnabled = checked;
            if (isAutoScrollEnabled) {
                showStatusMessage("接收区自动滚动已启用");
                ui->receiveTextEdit->verticalScrollBar()->setValue(ui->receiveTextEdit->verticalScrollBar()->maximum());
                ui->receiveTextEdit->update();
            } else {
                showStatusMessage("接收区自动滚动已禁用");
            }
        });
    }

    // 发送格式按钮组（QPushButton + QButtonGroup）：ASCII / Hex 互斥
    if (QPushButton* asciiSendBtn = this->findChild<QPushButton*>("asciiSendButton")) {
        if (QPushButton* hexSendBtn = this->findChild<QPushButton*>("hexSendButton")) {
            asciiSendBtn->setCheckable(true);
            hexSendBtn->setCheckable(true);
            QButtonGroup* sendGroup = new QButtonGroup(this);
            sendGroup->setExclusive(true);
            sendGroup->addButton(asciiSendBtn);
            sendGroup->addButton(hexSendBtn);
            if (isHexSend) {
                hexSendBtn->setChecked(true);
            } else {
                asciiSendBtn->setChecked(true);
            }
            connect(asciiSendBtn, &QPushButton::toggled, this, [this](bool checked){
                if (checked) { 
                    bool oldIsHexSend = isHexSend;
                    isHexSend = false;
                    // 只有当格式确实改变时才进行转换
                    if (oldIsHexSend != isHexSend) {
                        convertInputFormat();
                    }
                    validateSendInput(); 
                }
            });
            connect(hexSendBtn, &QPushButton::toggled, this, [this](bool checked){
                if (checked) { 
                    bool oldIsHexSend = isHexSend;
                    isHexSend = true;
                    // 只有当格式确实改变时才进行转换
                    if (oldIsHexSend != isHexSend) {
                        convertInputFormat();
                    }
                    validateSendInput(); 
                }
            });
        }
    }

    // 接收格式按钮组（QPushButton + QButtonGroup）：ASCII / Hex 互斥
    if (QPushButton* asciiRecvBtn = this->findChild<QPushButton*>("asciiReceiveButton")) {
        if (QPushButton* hexRecvBtn = this->findChild<QPushButton*>("hexReceiveButton")) {
            asciiRecvBtn->setCheckable(true);
            hexRecvBtn->setCheckable(true);
            QButtonGroup* recvGroup = new QButtonGroup(this);
            recvGroup->setExclusive(true);
            recvGroup->addButton(asciiRecvBtn);
            recvGroup->addButton(hexRecvBtn);
            if (isHexReceive) {
                hexRecvBtn->setChecked(true);
            } else {
                asciiRecvBtn->setChecked(true);
            }
            connect(asciiRecvBtn, &QPushButton::toggled, this, [this](bool checked){
                if (checked) { isHexReceive = false; }
            });
            connect(hexRecvBtn, &QPushButton::toggled, this, [this](bool checked){
                if (checked) { isHexReceive = true; }
            });
        }
    }

    updateStatsStatusBar();

    // 初始窗口大小设置为 800x760
    this->resize(800, 760);

    // 状态栏右侧添加“清空统计”按钮
    statusClearStatsButton = new QPushButton(QStringLiteral("清空统计"), this);
    statusClearStatsButton->setObjectName(QStringLiteral("clearStatsButton"));
    statusClearStatsButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    connect(statusClearStatsButton, &QPushButton::clicked, this, &MainWindow::on_clearStatsButton_clicked);
    statusBar()->addPermanentWidget(statusClearStatsButton);
}

/**
 * @brief 析构函数，负责清理资源与保存必要状态。
 * @details 关闭定时器、释放对象指针并确保在退出前写入设置或统计信息。
 */
MainWindow::~MainWindow()
{
    if (isConnected || serialPort->isOpen()) {
        updateConnectionStatus(false);
    }
    
    // 停止并释放定时检测串口的定时器
    if (portCheckTimer) {
        portCheckTimer->stop();
        delete portCheckTimer;
        portCheckTimer = nullptr;
    }
    
    // 释放自动发送定时器资源
    if (autoSendTimer) {
        delete autoSendTimer;
        autoSendTimer = nullptr;
    }
    
    // 释放接收缓冲定时器资源
    if (receiveFlushTimer) {
        delete receiveFlushTimer;
        receiveFlushTimer = nullptr;
    }
    
    saveSettings();
    delete ui;
}

// 时间戳和自动滚动功能现在通过按钮的toggled信号和lambda表达式处理

void MainWindow::on_receiveFlushTimer_timeout()
{
    if (pauseReceiving) {
        return;
    }
    if (dataIO->isReceiveBufferEmpty()) {
        // 无待刷新内容，停止定时器节省资源
        if (receiveFlushTimer->isActive()) receiveFlushTimer->stop();
        return;
    }
    // 批量拼接并追加
    QString chunk = dataIO->takeReceiveBufferLines().join("");

    QScrollBar *scrollBar = ui->receiveTextEdit->verticalScrollBar();
    bool atBottom = scrollBar->value() == scrollBar->maximum();
    ui->receiveTextEdit->insertPlainText(chunk);
    enforceMaxLines();

    if (isAutoScrollEnabled && atBottom) {
        scrollBar->setValue(scrollBar->maximum());
    }

    // 如果缓冲为空，停止定时器
    if (dataIO->isReceiveBufferEmpty() && receiveFlushTimer->isActive()) {
        receiveFlushTimer->stop();
    }

    // 更新速率到状态栏
    updateStatsStatusBar();
}

void MainWindow::enforceMaxLines()
{
    QTextDocument *doc = ui->receiveTextEdit->document();
    int blocks = doc->blockCount();
    if (blocks <= maxRetainedLines) return;
    int toRemove = blocks - maxRetainedLines;
    for (int i = 0; i < toRemove; ++i) {
        QTextBlock first = doc->firstBlock();
        if (!first.isValid()) break;
        QTextCursor cursor(doc);
        cursor.setPosition(first.position());
        cursor.movePosition(QTextCursor::NextBlock, QTextCursor::KeepAnchor);
        cursor.removeSelectedText();
    }
}

void MainWindow::findInReceive(const QString &text, bool highlightAll)
{
    if (text.isEmpty()) return;
    QTextDocument *doc = ui->receiveTextEdit->document();
    QTextCursor cursor(doc);
    QTextCharFormat fmt;
    fmt.setBackground(QBrush(Qt::yellow));

    if (highlightAll) {
        cursor.beginEditBlock();
        while (!cursor.isNull() && !cursor.atEnd()) {
            cursor = doc->find(text, cursor);
            if (!cursor.isNull()) {
                cursor.mergeCharFormat(fmt);
            }
        }
        cursor.endEditBlock();
    } else {
        cursor = doc->find(text);
        if (!cursor.isNull()) {
            ui->receiveTextEdit->setTextCursor(cursor);
        }
    }
}

/**
 * @brief 更新底部状态栏的统计信息。
 * @details 汇总接收/发送总量与瞬时速率等指标并展示。
 */
void MainWindow::updateStatsStatusBar()
{
    // 连接状态
    QString conn = isConnected ? "已连接" : "未连接";

    // 使用数据IO模块获取统计信息
    quint64 receivedBytes = dataIO->getReceivedBytesCount();
    quint64 sentBytes = dataIO->getSentBytesCount();
    double bps = dataIO->getCurrentReceiveRate();

    QString msg = QString("状态: %1 | 收: %2 B | 发: %3 B | 速率: %4 B/s")
                    .arg(conn)
                    .arg(receivedBytes)
                    .arg(sentBytes)
                    .arg(QString::number(bps, 'f', 2));
    showStatusMessage(msg);
}

/**
 * @brief 载入应用设置。
 * @details 读取上次保存的串口参数、显示选项与窗口状态并应用。
 */
void MainWindow::loadSettings()
{
    // 使用设置管理模块加载设置
    settingsManager->loadSettings();
    
    // 恢复窗口状态
    restoreGeometry(settingsManager->getWindowGeometry());
    restoreState(settingsManager->getWindowState());
    
    // 恢复UI选项
    isHexSend = settingsManager->getUiOption("hexSend", isHexSend).toBool();
    isHexReceive = settingsManager->getUiOption("hexReceive", isHexReceive).toBool();
    isTimestampEnabled = settingsManager->getUiOption("timestamp", isTimestampEnabled).toBool();
    isAutoScrollEnabled = settingsManager->getUiOption("autoScroll", isAutoScrollEnabled).toBool();
    pauseReceiving = settingsManager->getUiOption("pauseReceiving", pauseReceiving).toBool();
    
    // 恢复波特率
    ui->baudRateComboBox->setCurrentText(QString::number(settingsManager->getDefaultBaudRate()));
    
    // 配置数据IO模块
    dataIO->setHexSendEnabled(isHexSend);
    dataIO->setHexReceiveEnabled(isHexReceive);
    dataIO->setTimestampEnabled(isTimestampEnabled);
}

/**
 * @brief 保存应用设置。
 * @details 将当前配置写入持久化存储，便于下次启动恢复环境。
 */
void MainWindow::saveSettings()
{
    // 使用设置管理模块保存设置
    
    // 保存窗口状态
    settingsManager->setWindowState(saveGeometry(), saveState());
    
    // 保存UI选项
    settingsManager->setUiOption("hexSend", isHexSend);
    settingsManager->setUiOption("hexReceive", isHexReceive);
    settingsManager->setUiOption("timestamp", isTimestampEnabled);
    settingsManager->setUiOption("autoScroll", isAutoScrollEnabled);
    settingsManager->setUiOption("pauseReceiving", pauseReceiving);
    
    // 保存默认波特率
    bool ok = false;
    int baudRate = ui->baudRateComboBox->currentText().toInt(&ok);
    if (ok) {
        settingsManager->setDefaultPortParameters(
            baudRate,
            settingsManager->getDefaultDataBits(),
            settingsManager->getDefaultStopBits(),
            settingsManager->getDefaultParity(),
            settingsManager->getDefaultFlowControl()
        );
    }
    
    // 执行保存
    settingsManager->saveSettings();
}

/**
 * @brief 根据当前选项转换发送输入格式。
 * @details 在文本/HEX模式之间进行转换或预处理，便于后续校验与发送。
 */
/**
 * @brief 在状态栏显示提示信息。
 * @param message 要显示的消息文本。
 * @details 支持短暂提示或持久显示，用于反馈操作结果或错误信息。
 */
void MainWindow::showStatusMessage(const QString &message)
{
    statusBar()->showMessage(message, 5000);
}

/**
 * @brief 根据当前选项转换发送输入格式。
 * @details 在文本/HEX模式之间进行转换或预处理，便于后续校验与发送。
 */
void MainWindow::convertInputFormat()
{
    QString currentText = ui->sendTextEdit->toPlainText();
    if (currentText.isEmpty()) {
        return; // 空输入无需转换
    }
    
    // 保存当前光标位置（相对于文本末尾的偏移）
    QTextCursor cursor = ui->sendTextEdit->textCursor();
    int positionFromEnd = currentText.length() - cursor.position();
    
    // 首先尝试使用当前模式解析数据
    QByteArray data = dataIO->parseDataFromInput(currentText, !isHexSend); // 使用之前的模式解析
    
    // 然后转换为新格式
    QString newText;
    if (isHexSend) {
        // 转换为十六进制格式：每个字节两个字符，空格分隔
        for (int i = 0; i < data.size(); i++) {
            if (i > 0) newText.append(" ");
            newText.append(QString("%1").arg(static_cast<unsigned char>(data.at(i)), 2, 16, QLatin1Char('0')).toUpper());
        }
    } else {
        // 转换为ASCII格式
        newText = QString::fromUtf8(data);
    }
    
    // 更新输入框内容并恢复光标位置
    ui->sendTextEdit->setPlainText(newText);
    if (!newText.isEmpty()) {
        int newPosition = qMax(0, newText.length() - positionFromEnd);
        cursor.setPosition(newPosition);
        ui->sendTextEdit->setTextCursor(cursor);
    }
}

/**
 * @brief 校验发送输入合法性。
 * @details 检查空内容、HEX格式正确性与长度限制，决定是否启用发送按钮。
 */
void MainWindow::validateSendInput()
{
    const QString text = ui->sendTextEdit->toPlainText();
    
    // 在十六进制发送模式下，仍需要校验字符（但不影响发送按钮状态）
    if (isHexSend && !text.isEmpty()) {
        QRegularExpression re("^[0-9A-Fa-fxX,\\s]*$");
        if (!re.match(text).hasMatch()) {
            showStatusMessage("十六进制输入包含非法字符");
        }
    }
    
    // 修改：发送按钮始终保持可用，不考虑输入内容是否为空
    if (QWidget* w = this->findChild<QWidget*>("sendButton")) {
        w->setEnabled(true);
    }
}

/**
 * @brief 导出接收内容到文件。
 * @details 将接收区文本写入选定路径，可能支持追加或覆盖模式。
 */
void MainWindow::exportReceiveToFile()
{
    QString filter = "文本文件 (*.txt);;CSV 文件 (*.csv);;HEX 文件 (*.hex)";
    QString fileName = QFileDialog::getSaveFileName(this, "导出接收内容", QString(), filter);
    if (fileName.isEmpty()) return;
    QFile f(fileName);
    if (!f.open(QIODevice::WriteOnly | QIODevice::Text)) {
        QMessageBox::warning(this, "警告", "无法写入文件");
        return;
    }

    QString text = ui->receiveTextEdit->toPlainText();
    QByteArray out;
    if (fileName.endsWith(".csv", Qt::CaseInsensitive)) {
        // 简单CSV：每一行作为一条记录
        QStringList lines = text.split('\n');
        for (const QString &line : lines) {
            QString escaped = line;
            // CSV规范：字段中的双引号用两个双引号表示
            escaped.replace('"', "\"\"");
            out.append(QString("\"%1\"").arg(escaped).toUtf8());
            out.append("\n");
        }
    } else if (fileName.endsWith(".hex", Qt::CaseInsensitive)) {
        // HEX：如果当前接收为HEX模式，去掉空格/换行；否则按ASCII文本转十六进制
        if (isHexReceive) {
            QString compact = text;
            compact.remove(' ');
            compact.remove('\n');
            out = compact.toUtf8();
        } else {
            QByteArray bytes = text.toUtf8();
            QString hex;
            for (unsigned char c : bytes) {
                hex.append(QString("%1").arg(c, 2, 16, QLatin1Char('0')).toUpper());
            }
            out = hex.toUtf8();
        }
    } else {
        // TXT：原样导出
        out = text.toUtf8();
    }

    f.write(out);
    f.close();
    showStatusMessage("接收内容已导出");
}


/**
 * @brief 处理窗口尺寸变化。
 * @param event 尺寸变化事件对象。
 * @details 根据新尺寸调整控件布局或延迟重绘以提升性能。
 */
void MainWindow::resizeEvent(QResizeEvent *event)
{
    // 调用父类的resizeEvent
    QMainWindow::resizeEvent(event);
}

/**
 * @brief 重新格式化并重显示接收区数据。
 * @details 结合显示选项（时间戳、自动换行、HEX/ASCII）重新渲染文本。
 */
void MainWindow::reformatAndRedisplayData()
{
    // 保留此方法但简化为空实现，避免编译错误
    // 不再需要重新格式化数据
}

/**
 * @brief 处理窗口关闭事件。
 * @param event 关闭事件对象。
 * @details 执行清理、断开连接与设置保存，如需阻止关闭可在此处理。
 */
void MainWindow::closeEvent(QCloseEvent* event)
{
    // 断开串口连接
    if (isConnected) {
        serialManager->disconnectPort();
    }
    
    // 保存设置
    saveSettings();
    
    // 调用父类的closeEvent
    QMainWindow::closeEvent(event);
}

/**
 * @brief 事件过滤器。
 * @param obj 事件目标对象。
 * @param event 事件对象。
 * @return 是否拦截处理。
 * @details 用于封装跨控件的快捷键或特殊交互行为。
 */
bool MainWindow::eventFilter(QObject *obj, QEvent *event)
{
    // 检查是否是接收区的鼠标点击事件
    if (obj == ui->receiveTextEdit->viewport() && event->type() == QEvent::MouseButtonRelease) {
        // 如果启用了自动滚动，点击后滚动到最新内容
        if (isAutoScrollEnabled) {
            QScrollBar *scrollBar = ui->receiveTextEdit->verticalScrollBar();
            scrollBar->setValue(scrollBar->maximum());
        }
        return true;
    }
    // 其他情况使用默认处理
    return QMainWindow::eventFilter(obj, event);
}

void MainWindow::initializeUI()
{
    // 创建状态栏中的统计清除按钮
    statusClearStatsButton = new QPushButton("清除统计", this);
    statusBar()->addPermanentWidget(statusClearStatsButton);
    connect(statusClearStatsButton, &QPushButton::clicked, this, &MainWindow::clearReceiveStats);
    
    // 初始化状态栏
    showStatusMessage("就绪");
    
    // 设置定时器间隔（用于状态栏更新）
    statsUpdateTimer.setInterval(1000); // 每秒更新一次
    connect(&statsUpdateTimer, &QTimer::timeout, this, &MainWindow::updateStatsStatusBar);
    statsUpdateTimer.start();
    
    // 初始化串口状态缓存并启动自动检测
    if (serialManager) {
        serialManager->updatePortStatusCache();
        serialManager->startPortDetection();
    }
    // 扫描串口列表
    updatePortList();
}

void MainWindow::connectSignalsSlots()
{
    // 连接串口状态变化信号
    connect(serialManager, &SerialManager::connectionStatusChanged, this, &MainWindow::onConnectionStatusChanged);
    
    // 连接数据接收信号
    connect(serialManager, &SerialManager::dataReceived, this, &MainWindow::onDataReceived);
    
    // 连接错误信号
    connect(serialManager, &SerialManager::errorOccurred, [this](const QString &errorMessage) {
        showStatusMessage("串口错误: " + errorMessage);
        if (isConnected) {
            serialManager->disconnectPort();
        }
        updatePortList();
    });
    
    // 端口状态可能变更时刷新列表
    connect(serialManager, &SerialManager::portStatusChanged, this, &MainWindow::updatePortList);
}

void MainWindow::onDataReceived(const QByteArray &data)
{
    // 使用数据IO模块处理接收到的数据
    if (!pauseReceiving) {
        QString formattedData = dataIO->formatDataForDisplay(data, isHexReceive);
        appendToReceiveArea(formattedData);
    }
}

void MainWindow::sendData()
{
    if (!isConnected) return;
    
    // 使用数据IO模块处理和发送数据
    QString sendText = ui->sendTextEdit->toPlainText();
    QByteArray sendData = dataIO->parseDataFromInput(sendText, isHexSend);
    
    // 通过串口管理器发送数据
    serialManager->sendData(sendData);
    
    // 更新UI
    updateStatsStatusBar();
}

void MainWindow::appendToReceiveArea(const QString &text)
{
    // 实现文本追加逻辑，使用dataIO模块的功能
    if (text.isEmpty()) return;
    
    ui->receiveTextEdit->insertPlainText(text);
    
    // 自动滚动
    if (isAutoScrollEnabled) {
        QScrollBar *scrollBar = ui->receiveTextEdit->verticalScrollBar();
        scrollBar->setValue(scrollBar->maximum());
    }
}

void MainWindow::onConnectionStatusChanged(bool connected)
{
    isConnected = connected;
    
    // 更新UI状态
    updateUIConnectionState();
    
    // 更新状态栏
    updateStatsStatusBar();
    
    // 如果断开连接，更新端口列表
    if (!connected) {
        updatePortList();
    }
}

void MainWindow::updateConnectionStatus(bool connected)
{
    // 更新内部连接状态标志
    isConnected = connected;

    // 当状态变为未连接时，确保断开串口并刷新端口列表
    if (!connected) {
        if (serialManager) {
            serialManager->disconnectPort();
        }
        updatePortList();
    }

    // 同步更新UI与状态栏
    updateUIConnectionState();
    updateStatsStatusBar();
}

void MainWindow::updateUIConnectionState()
{
    // 更新UI控件状态
    if (QPushButton* btn = findChild<QPushButton*>("connectButton")) {
        btn->setText(isConnected ? "断开连接" : "连接" );        
    }
    ui->serialPortComboBox->setEnabled(!isConnected);
    ui->baudRateComboBox->setEnabled(!isConnected);
    ui->advancedSettingsButton->setEnabled(!isConnected);
}

void MainWindow::populatePortList()
{
    // 保存当前选中的串口
    QString currentPortName = ui->serialPortComboBox->currentText();
    
    // 清空并重新填充串口列表
    ui->serialPortComboBox->clear();
    
    // 使用SerialManager扫描可用串口
    QList<SerialPortInfo> ports = serialManager->getAvailablePorts();
    
    for (const SerialPortInfo &portInfo : ports) {
        QString displayText = portInfo.portName;
        if (!portInfo.description.isEmpty()) {
            displayText += " (" + portInfo.description + ")";
        }
        if (portInfo.status == SerialPortInfo::Busy) {
            displayText += " [占用]";
        } else if (portInfo.status == SerialPortInfo::NotFound) {
            displayText += " [未找到]";
        }
        
        ui->serialPortComboBox->addItem(displayText, portInfo.portName);
    }
    
    // 尝试恢复之前的选择
    int index = ui->serialPortComboBox->findText(currentPortName);
    if (index >= 0) {
        ui->serialPortComboBox->setCurrentIndex(index);
    }
}

void MainWindow::updatePortList()
{
    populatePortList();
}

void MainWindow::on_connectButton_clicked()
{
    if (!isConnected) {
        // 获取选中的端口和波特率
        QString portName = ui->serialPortComboBox->currentData().toString();
        bool ok = false;
        int baudRate = ui->baudRateComboBox->currentText().toInt(&ok);
        
        if (!ok || portName.isEmpty()) {
            showStatusMessage("请选择有效的端口和波特率");
            return;
        }
        
        // 使用串口管理器连接
        if (serialManager->connectPort(portName, baudRate)) {
            showStatusMessage("连接成功");
            // 添加到最近使用的端口历史
            settingsManager->addToPortHistory(portName);
        } else {
            showStatusMessage("连接失败: " + serialManager->getLastError());
        }
    } else {
        // 断开连接
        serialManager->disconnectPort();
    }
}

void MainWindow::clearReceiveStats()
{
    if (dataIO) {
        dataIO->clearStatistics();
    }
    showStatusMessage("统计已清空");
    updateStatsStatusBar();
}

void MainWindow::on_clearStatsButton_clicked()
{
    clearReceiveStats();
}

void MainWindow::on_clearReceiveButton_clicked()
{
    // 避免访问未初始化的 MainWindow::receiveFlushTimer，直接清理缓冲与UI
    if (dataIO) {
        dataIO->clearReceiveBuffer();
    }
    if (ui && ui->receiveTextEdit) {
        ui->receiveTextEdit->clear();
    }
    showStatusMessage("接收区已清空");
}

void MainWindow::on_clearSendButton_clicked()
{
    if (ui && ui->sendTextEdit) {
        ui->sendTextEdit->clear();
    }
    showStatusMessage("发送区已清空");
}

bool MainWindow::showSerialConnectionDialog()
{
    QMessageBox msgBox(this);
    msgBox.setWindowTitle(QStringLiteral("串口连接"));
    msgBox.setText(isConnected ? QStringLiteral("当前已连接，是否断开连接？")
                               : QStringLiteral("是否连接到选定串口？"));
    msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
    int ret = msgBox.exec();

    if (ret == QMessageBox::Yes) {
        if (!isConnected) {
            // 使用现有按钮逻辑进行连接，统一处理校验与状态更新
            on_connectButton_clicked();
        } else {
            // 通过统一的状态切换入口进行断开与UI更新
            updateConnectionStatus(false);
        }
        return true;
    }
    return false;
}
void MainWindow::checkSerialPortsAvailability()
{
    if (serialManager) {
        serialManager->updatePortStatusCache();
    }
    updatePortList();
}
void MainWindow::on_serialPortComboBox_currentIndexChanged(int index)
{
    Q_UNUSED(index);
    // 保持逻辑最小化，必要时可在此应用历史波特率或检测占用状态
}

void MainWindow::on_sendButton_clicked()
{
    sendData();
}

void MainWindow::on_refreshButton_clicked()
{
    checkSerialPortsAvailability();
}

void MainWindow::on_autoSendTimer_timeout()
{
    if (isConnected && isAutoSend) {
        sendData();
    }
}

void MainWindow::readSerialData()
{
    if (dataIO) {
        dataIO->readSerialData();
    }
}

void MainWindow::on_hexSendCheckBox_stateChanged(int arg1)
{
    isHexSend = (arg1 == Qt::Checked);
    validateSendInput();
}

void MainWindow::on_hexReceiveCheckBox_stateChanged(int arg1)
{
    isHexReceive = (arg1 == Qt::Checked);
    reformatAndRedisplayData();
}

void MainWindow::on_autoSendCheckBox_stateChanged(int arg1)
{
    isAutoSend = (arg1 == Qt::Checked);
}

void MainWindow::on_autoSendIntervalSpinBox_valueChanged(int arg1)
{
    if (dataIO) {
        dataIO->setAutoSendInterval(arg1);
    }
}

void MainWindow::on_advancedSettingsButton_clicked()
{
    QDialog dlg(this);
    dlg.setWindowTitle(QStringLiteral("参数设置"));
    QFormLayout *form = new QFormLayout(&dlg);

    // 串口下拉框
    QComboBox *port = new QComboBox(&dlg);
    if (serialManager) {
        serialManager->updatePortStatusCache();
        QList<SerialPortInfo> ports = serialManager->getAvailablePorts();
        if (ports.isEmpty()) {
            port->addItem(QStringLiteral("无可用串口"));
            port->setEnabled(false);
        } else {
            for (const SerialPortInfo &info : ports) {
                QString displayText = info.displayText.isEmpty() ? info.portName : info.displayText;
                port->addItem(displayText, info.portName);
            }
            // 预设当前主界面选择
            QString currentPortName = ui->serialPortComboBox->currentData().toString();
            int idx = port->findData(currentPortName);
            if (idx >= 0) port->setCurrentIndex(idx);
        }
    }

    // 参数下拉框
    QComboBox *baud = new QComboBox(&dlg);
    QComboBox *dataBits = new QComboBox(&dlg);
    QComboBox *stopBits = new QComboBox(&dlg);
    QComboBox *parity = new QComboBox(&dlg);
    QComboBox *flowControl = new QComboBox(&dlg);

    // 填充选项
    baud->addItems(serialManager->populateBaudRateList());
    dataBits->addItems(serialManager->populateDataBitsList());
    stopBits->addItems(serialManager->populateStopBitsList());
    parity->addItems(serialManager->populateParityList());
    flowControl->addItems(serialManager->populateFlowControlList());

    // 预设为当前默认参数
    baud->setCurrentText(QString::number(settingsManager->getDefaultBaudRate()));
    dataBits->setCurrentText(settingsManager->getDefaultDataBits());
    stopBits->setCurrentText(settingsManager->getDefaultStopBits());
    parity->setCurrentText(settingsManager->getDefaultParity());
    flowControl->setCurrentText(settingsManager->getDefaultFlowControl());

    // 表单布局
    form->addRow(QStringLiteral("串口"), port);
    form->addRow(QStringLiteral("波特率"), baud);
    form->addRow(QStringLiteral("数据位"), dataBits);
    form->addRow(QStringLiteral("停止位"), stopBits);
    form->addRow(QStringLiteral("校验位"), parity);
    form->addRow(QStringLiteral("流控制"), flowControl);

    // 确认/取消
    QDialogButtonBox *buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dlg);
    form->addRow(buttons);
    QObject::connect(buttons, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
    QObject::connect(buttons, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);

    // 打开对话框并处理结果
    if (dlg.exec() == QDialog::Accepted) {
        int baudRate = baud->currentText().toInt();
        QString dataBitsStr = dataBits->currentText();
        QString stopBitsStr = stopBits->currentText();
        QString parityStr = parity->currentText();
        QString flowStr = flowControl->currentText();
        QString selectedPortName = port->currentData().toString();

        // 保存到设置管理器
        settingsManager->setDefaultPortParameters(baudRate, dataBitsStr, stopBitsStr, parityStr, flowStr);
        if (!selectedPortName.isEmpty()) {
            settingsManager->addToPortHistory(selectedPortName);
        }
        settingsManager->saveSettings();

        // 更新主界面当前选择（端口与波特率）
        if (!selectedPortName.isEmpty()) {
            int idx = ui->serialPortComboBox->findData(selectedPortName);
            if (idx >= 0) ui->serialPortComboBox->setCurrentIndex(idx);
        }
        ui->baudRateComboBox->setCurrentText(QString::number(baudRate));

        showStatusMessage(QStringLiteral("参数设置已更新"));
    }
}